.TH std::ranges::zip_view::iterator 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::zip_view::iterator \- std::ranges::zip_view::iterator

.SH Synopsis
   template< bool Const >                                               \fB(1)\fP (exposition
   class /*iterator*/;                                                      only*)
   Helper concepts
   template< bool C, class... Views >

   concept /*all-forward*/ =                                            \fB(2)\fP (exposition
                                                                            only*)
       (ranges::forward_range<std::conditional_t<C, const Views,
   Views>> && ...);
   template< bool C, class... Views >

   concept /*all-bidirectional*/ =                                      \fB(3)\fP (exposition
                                                                            only*)
       (ranges::bidirectional_range<std::conditional_t<C, const Views,
   Views>> && ...);
   template< bool C, class... Views >

   concept /*all-random-access*/ =                                      \fB(4)\fP (exposition
                                                                            only*)
       (ranges::random_access_range<std::conditional_t<C, const Views,
   Views>> && ...);

   The iterator type of a possibly const-qualified zip_view, returned by
   zip_view::begin and in certain cases by zip_view::end.

   The type /*iterator*/<true> or /*iterator*/<false> treats the underlying views as
   const-qualified or non-const-qualified respectively.

.SH Member types

   Member type       Definition
                       * std::random_access_iterator_tag if
                         /*all-random-access*/<Const, Views...> is true, otherwise
                       * std::bidirectional_iterator_tag if
   iterator_concept      /*all-bidirectional*/<Const, Views...> is true, otherwise
                       * std::forward_iterator_tag if /*all-forward*/<Const, Views...>
                         is true, otherwise
                       * std::input_iterator_tag
                       * std::input_iterator_tag if /*all-forward*/<Const, Views...> is
   iterator_category     true,
                       * not defined otherwise
   value_type          * std::tuple<ranges::range_value_t<Views>...> if Const is false,
                       * std::tuple<ranges::range_value_t<const Views>...> otherwise.
                       * std::common_type_t<ranges::range_difference_t<Views>...> if
   difference_type       Const is false,
                       * std::common_type_t<ranges::range_difference_t<const Views>...>
                         otherwise.

   Data members

   Member object      Definition
                      A tuple of underlying iterators of type
                      std::tuple<ranges::iterator_t<Views>...> or
   current_ (private) std::tuple<ranges::iterator_t<const Views>...> when Const is
                      false or true respectively.
                      (exposition-only member object*)

.SH Member functions

   constructor     constructs an iterator
   (C++23)         \fI(public member function)\fP
   operator*       obtains a tuple-like value that consists of underlying pointed-to
   (C++23)         elements
                   \fI(public member function)\fP
   operator[]      obtains a tuple-like value that consists of underlying elements at
   (C++23)         given offset
                   \fI(public member function)\fP
   operator++
   operator++(int)
   operator--      advances or decrements the underlying iterators
   operator--(int) \fI(public member function)\fP
   operator+=
   operator-=
   (C++23)

.SH Non-member functions

   operator==
   operator<
   operator>   compares the underlying iterators
   operator<=  \fI(function)\fP
   operator>=
   operator<=>
   (C++23)
   operator+   performs iterator arithmetic on underlying iterators
   operator-   \fI(function)\fP
   (C++23)
   iter_move   obtains a tuple-like value that denotes underlying pointed-to elements
   (C++23)     to be moved
               \fI(function)\fP
   iter_swap   swaps underlying pointed-to elements
   (C++23)     \fI(function)\fP
